package com.dexing.od1;

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

/**
 *
 *
 * <blockquote>
 *  张三要去外地出差，需要做核酸，需要在指定时间点前做完核酸，请帮他找到满足条件的核酸检测点
 *      .给出一组核酸检测点的距离和每个核酸检测点当前的人数
 *      .给出张三要去做核酸的出发时间出发时间是10分钟的倍数
 *      同时给出张三做核酸的最晚结束时间.题目中给出的距离是整数，单位是公里，时间1分钟为一基本单位
 *      去找核酸点时，有如下的限制：
 *      .去往核酸点的路上，每公里距离花费时间10分钟，费用是10元
 *      .核酸点每检测一个人的时间花费是1分钟
 *      .每个核酸点工作时间都是8点到20点中间不休息核酸点准时工作，早到晚到都不检测.
 *   核酸检测结果可立刻知道.花在张三去某个核酸点的路上费的时间内，此核酸检测点的人数是动态变化的，变化规则是.
 *      在非核酸检测时间内，没有人排队.
 *      8点-10点每分钟增加3人
 *      .12点-14点每分钟增加10人
 *    要求将所有满足条件的核酸检测点按照优选规则排序列出：优选规则：
 *      .花费时间最少的核酸检测点排在前面。
 *      .花费时间一样,花费费用最少的核酸检测点排在前面。
 *      .时间和费用一样，则ID值最小的排在前面
 *  输入描述
 *  H1 M1
 *  H2 M2
 *  N
 *  ID1 D1 C1
 *  ID2 D2 C2
 *  ...
 *  IDn Dn Cn
 *  H1:当前时间的小时数。M1：当前时间的分钟数，
 *  H2：指定完成核算时间的小时数。M2：指定完成核算时间的分钟数。
 *  N：所有核酸检测点个数。
 *  ID1：核酸点的ID值。 D1：核酸检测点距离张三的距离。C1：核酸检测点当前检测的人数。
 *  输出描述:
 *  N
 *  I2 T2 M2
 *  I3 T3 M3
 *  N：满足要求的核酸检测点个数
 *  I2:选择后的核酸检测点ID T2:做完核酸花费的总时间(分钟) M2:去该核算点花费的费用
 *  示例一 输入
 *  10 30
 *  14 50
 *  3
 *  1 10 19
 *  2 8 20
 *  3 21 3
 *  输出：
 *  2
 *  2 80 80
 *  1 190 100
 * </blockquote>
 */
public class D2076CheckHeSuan {

    // 核酸点结构
    public static class Point {
        int id;
        //距离
        int dis;
        //排队人数
        int que;
        //总花费金钱
        int pay;
        //总花费时间
        int time;
    }

    // 人数增加情况
    public static final int[] add8_10 = {3, 480, 600};
    public static final int[] add12_14 = {10, 720, 840};

    public static void main(String[] args) {
        // 处理输入
        Scanner in = new Scanner(System.in);
        // 先将时间转换为分钟数
        int start = in.nextInt() * 60 + in.nextInt();
        int end = in.nextInt() * 60 + in.nextInt();
        int n = in.nextInt();

        // 构造核酸点
        Point[] points = new Point[n];
        for (int i = 0; i < points.length; i++) {
            Point point = new Point();
            point.id = in.nextInt();
            point.dis = in.nextInt();
            point.que = in.nextInt();
            point.pay = point.dis * 10;
            // 计算总耗时
            point.time = cal_time(start, point);
            points[i] = point;
        }

        //  按照给定的三条规则排序
        List<Point> res = Arrays.stream(points).filter(p -> start + p.time < end)
                .sorted((p1, p2) -> {
                    if (p1.time != p2.time) {
                        return p1.time - p2.time;
                    } else {
                        return p1.pay - p2.pay;
                    }
                }).collect(Collectors.toList());

        System.out.println(res.size());
        for (Point p : res) {
            System.out.print(p.id);
            System.out.print(" ");
            System.out.print(p.time);
            System.out.print(" ");
            System.out.println(p.pay);
        }

    }

    public static int cal_time(int start, Point point) {
        int total_time = 0;
        // 路程时间
        total_time += point.dis * 10;
        // 排队人数
        point.que = Math.max(0, point.que - point.dis * 10);
        // 到监测点的时间
        int on = start + point.dis * 10;

        // 到达时间的分支条件
        if (on <= add8_10[1]) {
            return add8_10[1] - start;
        } else if (on <= add8_10[2]) {
            point.que += (on - add8_10[1]) * add8_10[0] - (on - add8_10[1]);
            return total_time + point.que;
        } else if (on <= add12_14[1]) {
            return total_time + point.que;
        } else if (on <= add12_14[2]) {
            point.que += (on - add12_14[1]) * add12_14[0] - (on - add12_14[1]);
            return total_time + point.que;
        } else {
            return total_time + point.que;
        }
    }

}
